/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import java.util.*;
import java.util.Collections;
import Util.*;
import java.util.ArrayList;

/**
 *
 * @author u61851
 */
public final class MaqExpendedora extends MaqAutomata {

	private ArrayList<Producto> productos;

	/**
	 * Constructor Maquina Expendedora
	 * @param m ArrayList<Moneda> Monedas habilitadas para la circulacion
	 */
	public MaqExpendedora(ArrayList<Moneda> mon) {
		super(mon, null); // la maquina solo acepta monedas, y no reconoce ningun tipo de billete
		this.productos = new ArrayList<Producto>();

		Hashtable<Dinero, Integer> ht = new Hashtable<Dinero, Integer>();

		Fondo f = new Fondo(ht); // fondo vacio
		Cambio c = new Cambio(ht); // cambio vacio
		Monto m = new Monto(ht); // monto vacio

		this.setFondo(f); // fondo vacio
		this.setCambio(c); // cambio vacio
		this.setMonto(m); // monto vacio
	}

	/**
	 * Agregar un producto a la lista de productos que tiene la maquina
	 * @param p Producto
	 */
	public void addProducto(Producto p) {
		this.productos.add(p);
	}

	/**
	 * Obtener todos los productos que estan cargados en la maquina
	 * @return ArrayList<Producto>
	 */
	public ArrayList<Producto> getProductos() {
		return this.productos;
	}

	/**
	 * Devuelve un producto a partir del codigo de identificacion del mismo
	 * @param nCod Integer Codigo de identificacion del producto
	 * @return Producto
	 */
	public Producto getProducto(int nCod) {
		int i = 0;
		while (i < this.productos.size() && this.productos.get(i).getCodigo() != nCod) {
			i++;
		}
		if (i < this.productos.size()) {
			return this.productos.get(i);
		} else {
			return null;
		}

	}

	/**
	 * Borra un producto de la lista de productos de la maquina
	 * @param p Producto
	 */
	public void borrarProducto(Producto p) {
		productos.remove(p);
	}

	/**
	 * Obtiene el stock total de todos los productos, osea la suma de todos los stocks
	 * @return Integer Stock total
	 */
	public int getStockTotal() {
		int stock = 0;
		for (Producto p : productos) {
			stock += p.getStockReal();
		}
		return stock;
	}

	/**
	 * Agrega una X cantidad de stock a un Producto p
	 * @param p Producto
	 * @param nStock Integer
	 */
	public void addStock(Producto p, int nStock) {
		int stock = p.getStockReal();
		stock += nStock;
		p.setStockReal(stock);
	}

	/**
	 * Agrega stock a un producto seleccionado de acuerdo a su codigo
	 * @param cod Integer Codigo del Producto
	 * @return boolean
	 */
	public boolean agregarStock(int cod) {
		Producto p = this.getProducto(cod);
		Scanner in = new Scanner(System.in);
		int stock;

		if (p == null) {
			System.out.println("El producto no existe.");
			return false;
		} else {
			System.out.println("Ingrese la cantidad de stock que desea agregar: ");
			stock = in.nextInt();
			this.addStock(p, stock);
			return true;
		}

	}

	/**
	 * Devuelve el precio de un Producto p
	 * @param p Producto
	 * @return Integer
	 */
	public float getPrecio(Producto p) {
		return p.getPrecio();
	}

	/**
	 * De un ArrayList(Moneda) devuelve el importe ingresado, osea, la suma de los valores de las monedas que el ArrayList contiene
	 * @param importeIngresado ArrayList(Moneda)
	 * @return Float
	 */
	public float ingresarImporte(ArrayList<Moneda> importeIngresado) {
		// esto hay que agregarlo al monto ? -- NOO porque si la transaccion no se da, entonces estoy agregando algo que no corresponde
		float importe = 0;
		int cantidad = 0;
		//Monto monto = this.getMonto();

		Hashtable<Dinero, Integer> totalMonedas = new Hashtable<Dinero, Integer>();

		for (Moneda m : importeIngresado) {
			importe += m.getValor();

			if (totalMonedas.containsKey(m)) { // no se como actualizar un valor en el hashtable
				cantidad = (totalMonedas.get(m) + 1);
				totalMonedas.remove(m);
				totalMonedas.put(m, cantidad);
			} else {
				totalMonedas.put(m, new Integer(1));
			}
		}

		//monto.setValores(totalMonedas);
		//this.setMonto(monto);

		return importe;
	}

	/**
	 * Hace la transferencia de la gaseosa y devuelve un Hashtable(Dinero, Integer) con el vuelto
	 * @param p Producto
	 * @param importeIngresado Float
	 * @return Hashtable(Dinero, Integer) el vuelto de la operacion
	 */
	public Hashtable<Dinero, Integer> darGaseosa(Producto p, ArrayList<Moneda> importe) {
		int cantidad = 0;
		int i = 0;
		Moneda mon;
		float valorGaseosa = p.getPrecio();
		float importeIngresado = this.ingresarImporte(importe);
		float vuelto = (importeIngresado - valorGaseosa);
		Hashtable<Dinero, Integer> vueltoMonedas = new Hashtable<Dinero, Integer>();

		Fondo f = this.getFondo();

		Hashtable<Dinero, Integer> monedas = f.getValores(); // monedas que habilitadas en el fondo, para dar el vuelto, con su cantidad<Moneda, Cantidad>

		ArrayList<Moneda> monedasDisp = new ArrayList<Moneda>(); // monedas disponibles --TODAS LAS MONEDAS DEL FONDO

		for (Enumeration e = monedas.keys(); e.hasMoreElements();) {
			mon = (Moneda) e.nextElement();
			for (i = 0; i < monedas.get(mon); i++) { // agrego tantas monedas a la lista como monedas tenga
				monedasDisp.add(mon); // monedas que tengo disponibles para dar el vuelto
			}
		}

		Collections.sort(monedasDisp); // ordena las monedas de forma ascendente, esto es posible gracias a la implementacion de la interface Comparable por parte de la clase Dinero
		// y a overraidear el metodo compareTo.
		Moneda m;
		//for (Moneda m : monedasDisp) { // recorro todas las monedas
		for (int z = 0; z < monedasDisp.size() && vuelto > 0; z++) {
			m = monedasDisp.get(z);
			if (monedas.get(m) > 0 && vuelto >= m.getValor()) // si tengo cantidad de monedas y el vuelto es mayor al valor de la moneda
			{
				vuelto -= m.getValor(); // resto al vuelto el valor de la moneda
				if (vueltoMonedas.containsKey(m)) { // esto es lo mejor que se puede hacer??
					cantidad = vueltoMonedas.get(m) + 1;
					vueltoMonedas.remove(m); // lo borro y lo vuelvo a agregar con el contenido correcto
					vueltoMonedas.put(m, cantidad);
				} else {
					vueltoMonedas.put(m, new Integer(1)); // si no esta (la primera vez) lo agrego y le pongo cantidad
				}
			}
		}

		if (vuelto > 0) {
			return null;
		} else {

			Hashtable<Dinero, Integer> totalMonedas = new Hashtable<Dinero, Integer>();

			for (Moneda moneda : importe) {
				if (totalMonedas.containsKey(moneda)) { // no se como actualizar un valor en el hashtable
					cantidad = (totalMonedas.get(moneda) + 1);
					totalMonedas.remove(moneda);
					totalMonedas.put(moneda, cantidad);
				} else {
					totalMonedas.put(moneda, new Integer(1));
				}
			}

			Monto monto = new Monto(totalMonedas);
			this.setMonto(monto); // seteo el monto, y esto se agrega al fondo

			Cambio c = new Cambio(vueltoMonedas);
			this.setCambio(c); // seteo el cambio y se resta del fondo

			int stock = (p.getStockReal() - 1);
			p.setStockReal(stock); // se resta uno al stock del producto

			Date d = new Date(); // hoy
			int size = (this.getcAuditoria().size() + 1);
			Cinta cin = new Cinta(size, d, p, this.getCambio(), this.getMonto()); // creo la cinta

			this.addcAuditoria(cin); // agrego la cinta de auditoria

			return c.getCambio(); // devuelto el cambio
		}
	}

	/**
	 * Informa de las ventas del dia actual
	 * Movido desde la administradora. ver la clase para mas informacion sobre la declaracion alli
	 */
	public void informeVentasHoy() {
		Date hoy = new Date();

		System.out.println("Ventas del Dia de hoy ( " + hoy.toString() + " ): ");

		ArrayList<Cinta> cAuditoria = this.getcAuditoria();
		for (int i = 0; i < cAuditoria.size(); i++) {
			if (cAuditoria.get(i).getFechaTrans().getDay() == hoy.getDay()
					&& cAuditoria.get(i).getFechaTrans().getDate() == hoy.getDate()
					&& cAuditoria.get(i).getFechaTrans().getYear() == hoy.getYear()) {
				Producto prod = cAuditoria.get(i).getProducto();
				if (prod != null) {
					System.out.println("Transaccion:" + cAuditoria.get(i).getNroTrans());
					System.out.println("Producto:" + prod.getDetalle());
					System.out.println("Importe:" + prod.getPrecio());
					System.out.println("");
				}
			}
		}
	}

	/**
	 * Informa el estado de la maquina, esto es: cuanto dinero hay en la caja de cambio, en la de fondo y en la de vuelto
	 * Movido desde la administradora. ver la clase para mas informacion sobre la declaracion alli
	 */
	public void informeEstadoMaquina() {
		Cambio cambio = this.getCambio();
		Hashtable<Dinero, Integer> dinero = cambio.getValores();

		float nTotal = 0;
		for (Enumeration e = dinero.keys(); e.hasMoreElements();) {
			Dinero din = (Dinero) e.nextElement();
			nTotal += dinero.get(din) * din.getValor();
		}
		System.out.println("Cambio es de: " + nTotal);

		//fondo
		Fondo fondo = this.getFondo();
		dinero = fondo.getValores();

		nTotal = 0;
		for (Enumeration e = dinero.keys(); e.hasMoreElements();) {
			Dinero din = (Dinero) e.nextElement();

			nTotal += dinero.get(din) * din.getValor();

		}
		System.out.println("Fondo es de: " + nTotal);

		//monto
		Monto monto = this.getMonto();
		dinero = monto.getValores();

		nTotal = 0;
		for (Enumeration e = dinero.keys(); e.hasMoreElements();) {
			Dinero din = (Dinero) e.nextElement();
			nTotal += dinero.get(din) * din.getValor();
		}
		System.out.println("Monto es de: " + nTotal);
	}

	/**
	 * Da de alta un Producto pasandole el codigo, el detalle, el precio y el stock inicial
	 * @param codigo Integer
	 * @param detalle String
	 * @param precio Float
	 * @param stock Integer
	 */
	public void altaProducto(int codigo, String detalle, float precio, int stock) {
		Producto p = this.getProducto(codigo);
		int t = 0;
		if (p == null) // el producto no existe en la mauqina, entonces lo agrego
		{
			p = new Producto(codigo, detalle, precio, stock);
			this.addProducto(p);
		} else {
			System.out.println("El producto que intenta agregar ya existe");
		}
	}

	/**
	 * Da de baja un Producto dado su codigo de identificacion
	 * @param codigo Integer
	 */
	public boolean bajaProducto(int codigo) {
		Producto p = this.getProducto(codigo);
		if (p == null) {
			System.out.println("El producto que intenta borrar no existe");
			return false;
		} else {
			this.borrarProducto(p);
			return true;
		}
	}

	/**
	 * Informa el stock de un Producto dado su codigo de identificacion
	 * @param codigo Integer
	 */
	public void informarStockProducto(int codigo) {
		Producto p = this.getProducto(codigo);

		if (p != null) {
			System.out.println("El stock total para le producto " + p.getDetalle() + " es: " + p.getStockReal());
		} else {
			System.out.print("El producto no existe");
		}
	}

	/**
	 * Informa todo el stock, esto es la suma de todos los stocks de todos los productos
	 */
	public void informarTodoStock() {
		int stock = this.getStockTotal();
		System.out.println("Todo el Stock es: " + stock);
	}

	/**
	 * Informa el stock de cada Producto en forma detallada
	 */
	public void informarStockTodosProductosDetalle() {
		for (Producto p : this.getProductos()) {
			System.out.println("El stock para el producto " + p.getDetalle() + " (Cod. " + p.getCodigo() + ") " + " es: " + p.getStockReal());
		}
	}

	/**
	 * Informa el precio de un Producto dado su codigo de identificacion
	 * @param codigo Integer
	 */
	public void informarPrecio(int codigo) {
		Producto p = this.getProducto(codigo);
		if (p != null) {
			System.out.print("El precio es: " + p.getPrecio());
		} else {
			System.out.print("El producto no existe");
		}
	}

	/**
	 * Informa el precio de todos los productos
	 */
	public void informarPrecio() {
		for (Producto p : this.getProductos()) {
			System.out.println("El precio para el producto " + p.getDetalle() + " ( Cod. " + p.getCodigo() + " ) es: " + p.getPrecio());
		}
	}

	/**
	 * Da las opciones para modificar las caracteristicas de un producto dado su codigo de identificacion
	 * @param codigo Integer
	 */
	public void modificarProducto(int codigo) {
		Scanner in = new Scanner(System.in);
		Producto p = this.getProducto(codigo);
		int t = 0;
		String nDetalle;
		int nStock;
		float nPrecio;

		if (p == null) {
			System.out.println("El producto que intenta modificar no existe");
		} else {
			do {
				System.out.println("Ingrese la opcion que desea:"
						+ "\n\t1. Modificar detalle"
						+ "\n\t2. Modificar precio"
						+ "\n\t0. Salir");
				t = in.nextInt();
				switch (t) {
					case 1:
						System.out.print("Nuevo detalle: ");
						nDetalle = in.next();
						p.setDetalle(nDetalle);
						break;
					case 2:
						System.out.print("Nuevo precio: ");
						nPrecio = in.nextFloat();
						p.setPrecio(nPrecio);
						break;
				}
			} while (t != 0);
		}
	}

	/**
	 * Informa los productos que se cargaron en la maquina
	 */
	public void informarProductos() {
		for (Producto p : this.getProductos()) {
			System.out.println("\t" + p.getDetalle() + " (Cod. " + p.getCodigo() + ")");
		}
	}

	/**
	 * Guia al usuario a traves de diferentes pasos para que este obtenga una gaseosa
	 */
	public void darGaseosa() {
		Scanner in = new Scanner(System.in);

		ArrayList<Moneda> monedas = new ArrayList<Moneda>();
		Hashtable<Dinero, Integer> f = this.getFondo().getValores(); // este fondo siempre tiene monedas -- la maquina no acepta billetes

		for (Enumeration e = f.keys(); e.hasMoreElements();) {
			monedas.add((Moneda) e.nextElement());
		}

		ArrayList<Moneda> importe = new ArrayList<Moneda>();
		Hashtable<Dinero, Integer> vueltoMonedas = new Hashtable<Dinero, Integer>();
		Moneda m;
		int codigo;
		int t = 0;
		float importeMoneda = 0;

		System.out.println("Ingrese el codigo del producto que desea comprar: ");
		this.informarPrecio();
		codigo = in.nextInt();
		Producto p = this.getProducto(codigo);
		int z = 1;

		if (p != null) {
			if (p.getStockReal() > 0) { // si hay stock
				do {
					System.out.println("Ingrese el codigo de las monedas. 0. para salir");
					this.mostrarMonedas();
					t = in.nextInt();
					if (t != 0) {
						m = this.getMoneda(t);
						if (m == null) { // si la moneda existe
							System.out.println("La moneda que intenta ingresar no existe");
						} else {
							importe.add(m);
							importeMoneda += m.getValor();
						}
					} else if (importeMoneda < p.getPrecio()) {
						System.out.println("Le faltan monedas para completar la compra. Para Cancelar la operacion toque 0 o cualquier numero para continuar");
						z = in.nextInt();
					}
				} while ((t != 0 || importeMoneda < p.getPrecio()) && z != 0);

				if (z != 0)
				{

					vueltoMonedas = this.darGaseosa(p, importe);

					if (vueltoMonedas != null) { // si hay suficientes monedas para dar el cambio NO es null

						float vuelto = 0;
						Moneda mon;
						for (Enumeration e = vueltoMonedas.keys(); e.hasMoreElements();) {
							mon = (Moneda) e.nextElement();
							vuelto += mon.getValor() * vueltoMonedas.get(mon);
						}

						System.out.println("Su vuelto fue de $" + vuelto + " y fue dado en: ");
						for (Enumeration e = vueltoMonedas.keys(); e.hasMoreElements();) {
							m = (Moneda) e.nextElement();
							System.out.println(vueltoMonedas.get(m) + " monedas de $" + m.getValor()); // imprime: Su vuelto fue de: X monedas de $0.5
						}
						System.out.println("Retire su " + p.getDetalle());
					}
					else {
						System.out.println("No hay suficiente cantidad de monedas en el fondo para darle el vuelto. Ingrese monedas mas pequenas");
					}
				}
				else
					System.out.println("Se ha cancelado su compra");


			} else {
				System.out.println("No hay stock para este producto");
			}
		} else {
			System.out.println("No existe este producto");
		}
	}

	/**
	 * Informa las transacciones registradas en la cinta de auditoria
	 */
	public void informeDeAuditoria() {
		System.out.println("Las Tranferencias de la Cinta de Auditoria son las siguientes:");
		for (Cinta c : this.getcAuditoria()) {
			System.out.println("Transferencia: " + c.getNroTrans() + " para el producto: " + c.getProducto().getDetalle() + " en la fecha: " + c.getFechaTrans().toString());
		}
	}

	/**
	 * Informa cual es el producto mas vendido, y cual es la cantidad
	 */
	public void informarProductoMasVendido() {
		Producto p, pmax = null;
		int cant, max = 0;
		Hashtable<Producto, Integer> vendidos = new Hashtable<Producto, Integer>();

		for (Cinta c : this.getcAuditoria()) {
			p = c.getProducto();
			if (!vendidos.containsKey(p)) {
				vendidos.put(p, new Integer(1));
			} else {
				cant = (vendidos.get(p) + 1);
				vendidos.remove(p);
				vendidos.put(p, cant);
			}
		}
		for (Enumeration e = vendidos.keys(); e.hasMoreElements();) {
			p = (Producto) e.nextElement();
			if (max <= vendidos.get(p)) {
				max = vendidos.get(p);
				pmax = p;
			}
		}

		System.out.println("El producto mas vendido es: " + pmax.getDetalle() + " (Cod. " + pmax.getCodigo() + ") con " + max + " ventas");
	}

	/**
	 * Informa las ventas realizadas entre dos dias dados
	 * @param primerDia Date
	 * @param segundoDia Date
	 */
	public void informeVentasDosFechas(Date primerDia, Date segundoDia) {
		if (!primerDia.after(segundoDia)) {
			for (Cinta c : this.getcAuditoria()) {
				if (c.getFechaTrans().after(primerDia) && c.getFechaTrans().before(segundoDia)) // despues del primerDia y antes que el segundoDia
				{
					System.out.println("Transferencia: " + c.getNroTrans() + " para el producto " + c.getProducto().getDetalle() + " en el dia " + c.getFechaTrans());
				}
			}
		}
	}

	/**
	 * Inicia la simulacion de la Maquina
	 */
	public void iniciarSimulacion() {
		Scanner in = new Scanner(System.in);
		int cod, stock, ayo, mes, dia, opc = 0;
		boolean admin = false;
		String pass, detalle;
		float precio;
		char f;
		Date primerDia, segundoDia;

		System.out.println("===============\tSIMULACION: MAQUINA EXPENDEDORA DE GASEOSAS\t===============");
		do {

			if (admin == false) {
				System.out.println("Menu de opciones:"
						+ "\n\t1. Comprar Gaseosa"
						+ "\n\t2. Informar Precios"
						+ "\n\t3. Cambiar a Modo Administrador"
						+ "\n\t0. Terminar Simulacion");
				System.out.print("Ingrese la opcion que desea: ");
				opc = in.nextInt();

				switch (opc) {
					case 1:
						this.darGaseosa();
						break;
					case 2:
						this.informarPrecio();
						break;
					case 3:
						System.out.print("Ingrese el password del administrador para cambiar el modo: ");
						pass = in.next();

						if (pass.equals(MaqAutomata.getPwdAdmin())) {
							admin = true;
						} else {
							System.out.println("Password INCORRECTO");
						}
						break;
				}
			} else {
				System.out.println("Menu de opciones:"
						+ "\n\t1. Dar de Alta un Producto"
						+ "\n\t2. Dar de Baja un Producto"
						+ "\n\t3. Modificar un Producto"
						+ "\n\t4. Agregar Stock de un Producto"
						+ "\n\t5. Agregar Monedas en el Fondo"
						+ "\n\t6. Mostrar Cinta de Auditoria"
						+ "\n\t7. Mostrar Stock de un Producto"
						+ "\n\t8. Mostrar Stock de Todos los Productos"
						+ "\n\t9. Mostrar Monedas en el Fondo"
						+ "\n\t10. Calcular Ventas en un Rango de Fechas"
						+ "\n\t11. Informar Producto mas Vendido"
						+ "\n\t12. Informe diario de Ventas Realizadas"
						+ "\n\t13. Informe de Estado de la Maquina"
						+ "\n\t14. Cambiar Password de Administrador"
						+ "\n\t15. Cambiar a Modo Usuario "
						+ "\n\t0. Terminar Simulacion");
				System.out.print("Ingrese la opcion que desea: ");
				opc = in.nextInt();

				switch (opc) {
					case 1: // alta de producto
						do {
							System.out.print("Ingrese el codigo del producto: ");
							cod = in.nextInt();
							System.out.print("Ingrese el detalle del producto: ");
							detalle = in.next();
							System.out.print("Ingrese el precio del producto: ");
							precio = in.nextFloat();
							System.out.print("Ingrese el stock inicial del producto: ");
							stock = in.nextInt();

							this.altaProducto(cod, detalle, precio, stock);

							System.out.print("\nSi desea dar de Alta otro producto, presione 'y' O 'Y', sino 'n' O 'N' para salir.");
							f = in.next().charAt(0);
						} while ((f == 'y' || f == 'Y' || this.getProductos().isEmpty()) && f != 'n' && f != 'N'); // me aseguro de que haya productos

						break;
					case 2:
						System.out.println("Ingrese el codigo de producto que va a dar de baja");
						this.informarProductos();
						System.out.print("Codigo: ");
						cod = in.nextInt();

						this.bajaProducto(cod);

						break;
					case 3:
						System.out.println("Ingrese el codigo de Producto que desea Modificar");
						this.informarProductos();
						System.out.print("Codigo: ");
						cod = in.nextInt();

						this.modificarProducto(cod);

						break;
					case 4:
						System.out.println("Ingrese el codigo de Producto que desea Modificar");
						this.informarProductos();
						System.out.print("Codigo: ");
						cod = in.nextInt();

						this.agregarStock(cod);

						break;
					case 5:
						this.agregarMonedasAFondo();

						break;
					case 6:
						this.informeDeAuditoria();

						break;
					case 7:
						System.out.println("Ingrese el codigo de Producto que desea Modificar");
						this.informarProductos();
						System.out.print("Codigo: ");
						cod = in.nextInt();

						this.informarStockProducto(cod);

						break;
					case 8:
						this.informarStockTodosProductosDetalle();

						break;
					case 9:
						System.out.println("El Fondo tiene las siguientes Monedas: ");
						this.mostrarMonedasFondo();

						break;
					case 10:
						System.out.print("Ingrese el dia de la primer fecha (1-31): ");
						dia = in.nextInt();
						System.out.print("Ingrese el mes para la primer fecha (1-12): ");
						mes = in.nextInt();
						System.out.print("Ingrese el anio para la primer fecha (4 digitos): ");
						ayo = in.nextInt();

						primerDia = new Date((ayo - 1900), (mes - 1), dia);

						System.out.print("\nIngrese el dia de la segunda fecha (1-31): ");
						dia = in.nextInt();
						System.out.print("Ingrese el mes para la segunda fecha (1-12): ");
						mes = in.nextInt();
						System.out.print("Ingrese el anio para la segunda fecha (4 digitos): ");
						ayo = in.nextInt();

						segundoDia = new Date((ayo - 1900), (mes - 1), dia);

						this.informeVentasDosFechas(primerDia, segundoDia);

						break;
					case 11:
						this.informarProductoMasVendido();

						break;
					case 12:
						this.informeVentasHoy();

						break;
					case 13:
						this.informeEstadoMaquina();

						break;
					case 14:
						System.out.print("Ingrese el password del Administrador: ");
						pass = in.next();

						if (pass.equals(MaqAutomata.getPwdAdmin())) {
							System.out.print("Ingrese el nuevo password: ");
							pass = in.next();
							this.setPwdAdmin(pass);
						} else {
							System.out.println("Password INCORRECTO");
						}

						break;
					case 15:
						admin = false;

						break;
				}
			}
		} while (opc != 0);
	}
}
